﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Net;

namespace wfGeneradorWeb
{
    class ftp
    {
        private string host = null;
        private string user = null;
        private string pass = null;
        private FtpWebRequest ftpRequest = null;
        private FtpWebResponse ftpResponse = null;
        private Stream ftpStream = null;
        private int bufferSize = 2048;

        public ftp(string hostIP, string userName, string password)
        { host = hostIP; user = userName; pass = password; }

        public void upload(string remoteFile, string localFile)
        {
            try
            {
                /* Create an FTP Request */
                string uri = host + "/" + remoteFile + "/" + Path.GetFileName(localFile);
                ftpRequest = (FtpWebRequest)FtpWebRequest.Create(uri);
                /* Log in to the FTP Server with the User Name and Password Provided */
                ftpRequest.Credentials = new NetworkCredential(user, pass);
                /* When in doubt, use these options */
                ftpRequest.UseBinary = true;
                ftpRequest.UsePassive = true;
                ftpRequest.KeepAlive = true;
                /* Specify the Type of FTP Request */
                ftpRequest.Method = WebRequestMethods.Ftp.UploadFile;
                /* Establish Return Communication with the FTP Server */
                ftpStream = ftpRequest.GetRequestStream();
                /* Open a File Stream to Read the File for Upload */
                FileStream localFileStream = new FileStream(localFile, FileMode.Create);
                /* Buffer for the Downloaded Data */
                byte[] byteBuffer = new byte[bufferSize];
                int bytesSent = localFileStream.Read(byteBuffer, 0, bufferSize);
                /* Upload the File by Sending the Buffered Data Until the Transfer is Complete */
                try
                {
                    while (bytesSent != 0)
                    {
                        ftpStream.Write(byteBuffer, 0, bytesSent);
                        bytesSent = localFileStream.Read(byteBuffer, 0, bufferSize);
                    }
                }
                catch (Exception ex) { Console.WriteLine(ex.ToString()); }
                /* Resource Cleanup */
                localFileStream.Close();
                ftpStream.Close();
                ftpRequest = null;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
            return;
        }

        public void UploadFTP(string FilePath, string RemotePath)
        {

            using (FileStream fs = new FileStream(FilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                string url = host + "/" + RemotePath + "/"+ Path.GetFileName(FilePath);
                // Creo el objeto ftp
                FtpWebRequest ftp = (FtpWebRequest)FtpWebRequest.Create(url);
                // Fijo las credenciales, usuario y contraseña
                ftp.Credentials = new NetworkCredential(user, pass);
                // Le digo que no mantenga la conexión activa al terminar.
                ftp.KeepAlive = false;
                // Indicamos que la operación es subir un archivo...
                ftp.Method = WebRequestMethods.Ftp.UploadFile;                
                // â€¦ en modo binario â€¦ (podria ser como ASCII)
                ftp.UseBinary = true;
                // Indicamos la longitud total de lo que vamos a enviar.
                ftp.ContentLength = fs.Length;
                // Desactivo cualquier posible proxy http.
                // Ojo pues de saltar este paso podría usar 
                // un proxy configurado en iexplorer
                ftp.Proxy = null;
                // Pongo el stream al inicio
                fs.Position = 0;
                // Configuro el buffer a 2 KBytes
                int buffLength = 2048;
                byte[] buff = new byte[buffLength];
                int contentLen;
                // obtener el stream del socket sobre el que se va a escribir.
                using (Stream strm = ftp.GetRequestStream())
                {
                    // Leer del buffer 2kb cada vez
                    contentLen = fs.Read(buff, 0, buffLength);
                    // mientras haya datos en el buffer â€¦.
                    while (contentLen != 0)
                    {
                        // escribir en el stream de conexión
                        //el contenido del stream del fichero
                        strm.Write(buff, 0, contentLen);
                        contentLen = fs.Read(buff, 0, buffLength);
                    }
                }
            }
        }

        public void CrearDirectorio(string RemotePath, string carpeta)
        {
            string url = host + "/" + RemotePath + "/" + carpeta;
            FtpWebRequest ftp = (FtpWebRequest)FtpWebRequest.Create(url);
            // Fijo las credenciales, usuario y contraseña
            ftp.Credentials = new NetworkCredential(user, pass);
            ftp.Method = WebRequestMethods.Ftp.MakeDirectory;
            try
            {
                FtpWebResponse respuesta;
                respuesta = (FtpWebResponse)ftp.GetResponse();
                respuesta.Close();
                // Si todo ha ido bien, se devolverá String.Empty 
                //return string.Empty;

            }
            catch (Exception ex)
            {
                // Si se produce algún fallo, se devolverá el mensaje del error 
                //return ex.Message;
            } 
        }

        public Boolean verificaExitencia(string RemotePath,string nombreObjeto)
        {
            string url = host + "/" + RemotePath ;
            FtpWebRequest dirFtp = ((FtpWebRequest)FtpWebRequest.Create(url));
            Boolean respuesta = false;

            // Los datos del usuario (credenciales) 
            NetworkCredential cr = new NetworkCredential(user, pass);
            dirFtp.Credentials = cr;


            // El comando a ejecutar 
            //dirFtp.Method = "LIST";

            // También usando la enumeración de WebRequestMethods.Ftp 
            dirFtp.Method = WebRequestMethods.Ftp.ListDirectory;

            // Obtener el resultado del comando 
            StreamReader reader =
            new StreamReader(dirFtp.GetResponse().GetResponseStream());

            // Leer el stream 
            string res = "";//reader.ReadLine(); 
            //Response.Write(res); 

            while (!reader.EndOfStream)
            {
                res = reader.ReadLine();

                if (res == nombreObjeto)
                {
                    respuesta = true;
                }

            }
            reader.Close();
            return respuesta;
        } 
    }
}
